/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package itm.dao.productos;

//~--- non-JDK imports --------------------------------------------------------
import itm.exception.ControlException;

import itm.exception.DAOException;
import itm.vo.administracion.CategoriaProductosVO;
import itm.vo.administracion.ClaseProductoVO;
import itm.vo.administracion.DestinosProductosVO;
import itm.vo.administracion.TipoEventosVO;
import itm.vo.administracion.TipoVO;
import itm.vo.administracion.TiposUsosVO;
import itm.vo.file.ArchivoVO;
import itm.vo.grupoInvestigacion.CiudadVO;
import itm.vo.grupoInvestigacion.EventoVO;
import itm.vo.grupoInvestigacion.GrupoInvestigacionVO;
import itm.vo.grupoInvestigacion.PaisVO;
import itm.vo.personas.PersonaVO;
import itm.vo.prodructos.ArchivoProductoVO;
import itm.vo.prodructos.AtributosVO;
import itm.vo.prodructos.CriteObservaProduVO;
import itm.vo.prodructos.EstadoVO;
import itm.vo.prodructos.EvaluacionProductoVO;
import itm.vo.prodructos.ItemEvaluacionVO;
import itm.vo.prodructos.ProductoUsoVO;
import itm.vo.prodructos.ProductoVO;
import itm.vo.prodructos.ProductosEventoVO;
import itm.vo.prodructos.PropiedadIntelectualVO;
import itm.vo.proyectosInvestigacion.ProyectoInvestigacionVO;

//~--- JDK imports ------------------------------------------------------------

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author BISA20
 */
public class ProductosDAO {

    private CallableStatement callStmt = null;
    private ResultSet res = null;
    private String sql = "";
    String temp = "";
    Connection dbConexion;

    public ProductosDAO(Connection dbConexion) {
        this.dbConexion = dbConexion;
    }

    public List<ArchivoVO> consultarArchivosProducto(ProductoVO productoVO) throws ControlException, SQLException {
        List<ArchivoVO> listaArchivo = new ArrayList<ArchivoVO>();
        ArchivoVO archivoVO;

        try {
            sql = "{call ITM_CONSULTAR_ARCHIVOS_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getIdProducto());
            res = callStmt.executeQuery();

            while (res.next()) {
                archivoVO = new ArchivoVO();
                archivoVO.setIdArchivoVO(res.getInt(1));
                archivoVO.setModulo(res.getString(2));
                archivoVO.setNombreArchivo(res.getString(3));
                archivoVO.setDescripcion(res.getString(4));
                archivoVO.setRutaArchivo(res.getString(5));
                archivoVO.setFechaArchivo(res.getDate(6));
                listaArchivo.add(archivoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaArchivo;
    }

    public String crearAtributosProducto(AtributosVO atributosVO) throws ControlException, SQLException {
        try {
            sql = "{call ITM_CREAR_ATRIBUTOS_PRODUCTO(?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, atributosVO.getIdTipoProducto());
            callStmt.setString(3, atributosVO.getLongitud());
            callStmt.setString(4, atributosVO.getEspecifico());
            callStmt.setString(5, atributosVO.getIdTipoAtributo());
            callStmt.setString(6, atributosVO.getNombreAtributo());
            callStmt.setString(7, atributosVO.getIndicadorVerificacion());
            callStmt.execute();
            temp = callStmt.getString(1);
            
        } catch (SQLException ce) {
            ce.printStackTrace();
            throw new SQLException("Error al insertar en la base de datos", ce);
        }

        return temp;
    }

    public String modificarAtributosProducto(AtributosVO atributosVO) throws ControlException, SQLException {
        try {
            sql = "{call ITM_ACTUALIZAR_ATRIBUTOS_PRODUCTO(?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, atributosVO.getIdAtributoProducto());
            callStmt.setString(3, atributosVO.getIdTipoProducto());
            callStmt.setString(4, atributosVO.getLongitud());
            callStmt.setString(5, atributosVO.getEspecifico());
            callStmt.setString(6, atributosVO.getIdTipoAtributo());
            callStmt.setString(7, atributosVO.getNombreAtributo());
            callStmt.setString(8, atributosVO.getIndicadorVerificacion());
            callStmt.execute();
            temp = callStmt.getString(1);

            String qq = temp;
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public List<CategoriaProductosVO> listarCategoria() throws Exception {
        List<CategoriaProductosVO> listaCategoria = new ArrayList<CategoriaProductosVO>();
        CategoriaProductosVO categoriaProductosVO;

        try {
            sql = "{call ITM_LISTA_CATEGORIAS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                categoriaProductosVO = new CategoriaProductosVO();
                categoriaProductosVO.setIdCategoria(res.getString(1));
                categoriaProductosVO.setNombreCategoria(res.getString(2));
                listaCategoria.add(categoriaProductosVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaCategoria;
    }

    public List<GrupoInvestigacionVO> listarGrupoInvestigacion() throws Exception {
        List<GrupoInvestigacionVO> listaGrupo = new ArrayList<GrupoInvestigacionVO>();
        GrupoInvestigacionVO grupoInvestigacionVO;

        try {
            sql = "{call ITM_LISTA_GRUPO_INV()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                grupoInvestigacionVO = new GrupoInvestigacionVO();
                grupoInvestigacionVO.setIdGrupo(res.getInt(1));
                grupoInvestigacionVO.setNombreGrupo(res.getString(2));
                listaGrupo.add(grupoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaGrupo;
    }

    public List<ProductoVO> listarTipoPropiedad() throws Exception {
        List<ProductoVO> listaTipoPropiedad = new ArrayList<ProductoVO>();
        ProductoVO productoVO;

        try {
            sql = "{call ITM_LISTA_TIPO_PROPIEDAD_INTELECTUAL()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                productoVO = new ProductoVO();
                productoVO.setIdTipoP(res.getString(1));
                productoVO.setNombreTipoPropiedad(res.getString(2));
                listaTipoPropiedad.add(productoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaTipoPropiedad;
    }

    public List<ClaseProductoVO> listarClase() throws Exception {
        List<ClaseProductoVO> listaClase = new ArrayList<ClaseProductoVO>();
        ClaseProductoVO claseProductoVO;

        try {
            sql = "{call ITM_LISTA_CLASE_PRODUCTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                claseProductoVO = new ClaseProductoVO();
                claseProductoVO.setIdClaseProducto(res.getString(1));
                claseProductoVO.setNombreClaseProducto(res.getString(2));
                listaClase.add(claseProductoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaClase;
    }

    public List<CriteObservaProduVO> listarCriteriosProducto() throws Exception {
        List<CriteObservaProduVO> listaCriterios = new ArrayList<CriteObservaProduVO>();
        CriteObservaProduVO criteObservaProduVO;

        try {
            sql = "{call ITM_LISTA_CRITERIOS_OBSERVACION_PRODUCTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                criteObservaProduVO = new CriteObservaProduVO();
                criteObservaProduVO.setNombreCriterio(res.getString(1));
                criteObservaProduVO.setIdCriterio(res.getString(2));
                listaCriterios.add(criteObservaProduVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaCriterios;
    }

    public List<TipoVO> listarTipo() throws Exception {
        List<TipoVO> listaTipo = new ArrayList<TipoVO>();
        TipoVO tipoVO;

        try {
            sql = "{call ITM_LISTAR_TIPO_PRODUCTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                tipoVO = new TipoVO();
                tipoVO.setIdTipoProducto(res.getString(1));
                tipoVO.setNombreTipoProducto(res.getString(2));
                listaTipo.add(tipoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaTipo;
    }

    public List<ProductoVO> listaEstado() throws Exception {
        List<ProductoVO> listaEstado = new ArrayList<ProductoVO>();
        ProductoVO productoVO;

        try {
            sql = "{call ITM_LISTA_ESTADO_PRODUCTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                productoVO = new ProductoVO();
                productoVO.setIdEstado(res.getString(1));
                productoVO.setNombreEstado(res.getString(2));
                listaEstado.add(productoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaEstado;
    }

    public List<ProyectoInvestigacionVO> listarProyecto() throws Exception {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;

        try {
            sql = "{call ITM_LISTAR_PROYECTOS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getInt(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public List<PersonaVO> listarPersonas(PersonaVO personaVO) throws Exception {
        List<PersonaVO> listaPersonas = new ArrayList<PersonaVO>();

        // PersonaVO  personaVO;
        try {
            sql = "{call ITM_LISTAR_PERSONAS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                personaVO = new PersonaVO();
                personaVO.setIdPersona(res.getString(1));
                personaVO.setNombrePersona(res.getString(2));
                listaPersonas.add(personaVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaPersonas;
    }

    public List<PersonaVO> listarCoopropietarios() throws Exception {
        List<PersonaVO> listaPersonas = new ArrayList<PersonaVO>();
        PersonaVO personaVO;

        try {
            sql = "{call ITM_LISTAR_PERSONAS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                personaVO = new PersonaVO();
                personaVO.setIdPersona(res.getString(1));
                personaVO.setNombrePersona(res.getString(2));
                listaPersonas.add(personaVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaPersonas;
    }

    public List<TipoEventosVO> listarTipoEventos() throws Exception {
        List<TipoEventosVO> listaTipoEventos = new ArrayList<TipoEventosVO>();
        TipoEventosVO tipoEventosVO;

        try {
            sql = "{call ITM_LISTA_EVENTOS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                tipoEventosVO = new TipoEventosVO();
                tipoEventosVO.setIdTipoEvento(res.getString(1));
                tipoEventosVO.setNombreTipoEvento(res.getString(2));
                listaTipoEventos.add(tipoEventosVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaTipoEventos;
    }

    public List<PaisVO> listarPaises() throws Exception {
        List<PaisVO> listaPais = new ArrayList<PaisVO>();
        PaisVO paisVO;

        try {
            sql = "{call ITM_LISTA_PAISES()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                paisVO = new PaisVO();
                paisVO.setIdPais(res.getInt(1));
                paisVO.setPais(res.getString(2));
                listaPais.add(paisVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaPais;
    }

    public List<CiudadVO> listarCiudadesSegunPais(PaisVO paisVO) throws Exception {
        List<CiudadVO> listaCiudades = new ArrayList<CiudadVO>();
        CiudadVO ciudadVO;

        try {
            sql = "{call ITM_LISTA_CIUDADES(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setInt(1, paisVO.getIdPais());
            res = callStmt.executeQuery();

            while (res.next()) {
                ciudadVO = new CiudadVO();
                ciudadVO.setIdCiudad(res.getInt(1));
                ciudadVO.setCiudad(res.getString(2));
                listaCiudades.add(ciudadVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaCiudades;
    }

    public List<TiposUsosVO> listarTipoUsos() throws Exception {
        List<TiposUsosVO> listaTipoUso = new ArrayList<TiposUsosVO>();
        TiposUsosVO tiposUsosVO;

        try {
            sql = "{call ITM_LISTA_TIPO_USO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                tiposUsosVO = new TiposUsosVO();
                tiposUsosVO.setIdTipoUso(res.getString(1));
                tiposUsosVO.setNombreTipoUso(res.getString(2));
                listaTipoUso.add(tiposUsosVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaTipoUso;
    }

    public List<DestinosProductosVO> listarDestinosProduc() throws Exception {
        List<DestinosProductosVO> listaDestinos = new ArrayList<DestinosProductosVO>();
        DestinosProductosVO destinosProductosVO;

        try {
            sql = "{call ITM_LISTA_DESTINO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                destinosProductosVO = new DestinosProductosVO();
                destinosProductosVO.setIdDestinos(res.getString(1));
                destinosProductosVO.setNombreDestinos(res.getString(2));
                listaDestinos.add(destinosProductosVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaDestinos;
    }

    public int registroEventos(EventoVO eventoVO) throws Exception {
        int temp1 = 0;

        try {
            sql = "{call ITM_CREAR_REGISTRO_EVENTOS(?,?,?,?,?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, eventoVO.getIdTipoEvento());
            callStmt.setString(3, eventoVO.getNombreEvento());
            callStmt.setString(4, eventoVO.getDescripcion());
            callStmt.setString(5, eventoVO.getOrganizador());
            callStmt.setInt(6, eventoVO.getIdPais());
            callStmt.setInt(7, eventoVO.getIdCiudad());
            callStmt.setDate(8, eventoVO.getFechaInicio());
            callStmt.setDate(9, eventoVO.getFechaFin());
            callStmt.setString(10, eventoVO.getDuracion());
            callStmt.setString(11, eventoVO.getImportanciaITM());
            callStmt.setString(12, eventoVO.getDetalleCosto());
            callStmt.setString(13, eventoVO.getAsumeCosto());
            callStmt.execute();
            temp = callStmt.getString(1);
            temp1 = Integer.parseInt(temp);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp1;
    }

    public String modificarEventos(EventoVO eventoVO, ProductoVO productoVO) throws Exception {
        try {
            sql = "{call ITM_MODIFICAR_EVENTO(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, eventoVO.getIdEvento());
            callStmt.setInt(3, eventoVO.getIdTipoEvento());
            callStmt.setString(4, eventoVO.getNombreEvento());
            callStmt.setString(5, eventoVO.getDescripcion());
            callStmt.setString(6, eventoVO.getOrganizador());
            callStmt.setInt(7, eventoVO.getIdPais());
            callStmt.setInt(8, eventoVO.getIdCiudad());
            callStmt.setDate(9, eventoVO.getFechaInicio());
            callStmt.setDate(10, eventoVO.getFechaFin());
            callStmt.setString(11, eventoVO.getDuracion());
            callStmt.setString(12, eventoVO.getImportanciaITM());
            callStmt.setString(13, eventoVO.getDetalleCosto());
            callStmt.setString(14, eventoVO.getAsumeCosto());
            callStmt.setString(15, productoVO.getEnproceso());
            callStmt.setString(16, productoVO.getCostoAsociado());
            callStmt.setString(17, productoVO.getResultadoObtenido());
            callStmt.execute();
            temp = callStmt.getString(1);

        // temp1= Integer.parseInt(temp);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String resgistroEventosProducGru(ProductoVO productoVO) throws Exception {
        try {
            sql = "{call ITM_CREAR_PRODUCTO_EVENTO(?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoVO.getIdProducto());
            callStmt.setString(3, productoVO.getIdevento());
            callStmt.setString(4, productoVO.getEnproceso());
            callStmt.setString(5, productoVO.getCostoAsociado());
            callStmt.setString(6, productoVO.getResultadoObtenido());
            callStmt.setString(7, productoVO.getIdGrupo());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String resgistroEvenProductPersonas(ProductoVO productoVO) throws Exception {
        try {
            sql = "{call ITM_CREAR_PRODUCTO_EVENTO_PERSONAS(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoVO.getIdevento());
            callStmt.setString(3, productoVO.getIdPersona());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String resgistroUsoPersonas(ProductoUsoVO productoUsoVO) throws Exception {
        try {
            sql = "{call ITM_CREAR_PRODUCTO_USO_PERSONA(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoUsoVO.getIdUso());
            callStmt.setString(3, productoUsoVO.getIdPersona());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String resgistroUsoGrupo(ProductoUsoVO productoUsoVO) throws Exception {
        try {
            sql = "{call ITM_CREAR_PRODUCTO_USO_GRUPO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoUsoVO.getIdUso());
            callStmt.setString(3, productoUsoVO.getIdGrupo());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public List<ProductoVO> consultarEventos() throws Exception {
        List<ProductoVO> listaEventos = new ArrayList<ProductoVO>();
        ProductoVO productoVO;

        try {
            sql = "{call ITM_CONSULTAR_EVENTO_PRODUCTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                productoVO = new ProductoVO();
                productoVO.setNombreProducto(res.getString(1));
                productoVO.setNombreEvento(res.getString(2));
                productoVO.setIdevento(res.getString(3));
                listaEventos.add(productoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaEventos;
    }

    public ProductosEventoVO consultarEventoEspecifico(ProductosEventoVO productosEventoVO)
            throws ControlException, SQLException {

        // ProductosEventoVO  productosEventoVO=new ProductosEventoVO();
        try {
            sql = "{call ITM_CONSULTAR_EVENTOESPECIFICO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productosEventoVO.getIdEvento());
            res = callStmt.executeQuery();

            if (res.next()) {
                productosEventoVO.setNombreEvento(res.getString(1));
                productosEventoVO.setDescripcion(res.getString(2));
                productosEventoVO.setOrganizador(res.getString(3));
                productosEventoVO.setNombrePais(res.getString(4));
                productosEventoVO.setNombreCiudad(res.getString(5));
                productosEventoVO.setFechaInicio(res.getString(6));
                productosEventoVO.setFechaFin(res.getString(7));
                productosEventoVO.setDuracion(res.getString(8));
                productosEventoVO.setImportanciaItm(res.getString(9));
                productosEventoVO.setDetalleCosto(res.getString(10));
                productosEventoVO.setAsumeCosto(res.getString(11));
                productosEventoVO.setCostoAsociado(res.getString(12));
                productosEventoVO.setResultadoObtenido(res.getString(13));
                productosEventoVO.setTipoEvento(res.getString(14));
                productosEventoVO.setEnProceso(res.getString(15));

            // listaPersonas.add(personaVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return productosEventoVO;
    }

    public List<ProductosEventoVO> consultarResponsables(ProductosEventoVO productosEventoVO)
            throws ControlException, SQLException {
        List<ProductosEventoVO> listaResponsable = new ArrayList<ProductosEventoVO>();

        try {
            sql = "{call ITM_CONSULTAR_RESPONSABLES(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productosEventoVO.getIdEvento());
            res = callStmt.executeQuery();

            while (res.next()) {
                productosEventoVO = new ProductosEventoVO();
                productosEventoVO.setResponsable(res.getString(1));
                listaResponsable.add(productosEventoVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaResponsable;
    }

    public String resgistroUsosProducto(ProductoUsoVO productoUsoVO) throws Exception {
        try {
            sql = "{call ITM_CREAR_USO(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoUsoVO.getIdTipoUso());
            callStmt.setString(3, productoUsoVO.getDescripcionUso());
            callStmt.setString(4, productoUsoVO.getDestino());
            callStmt.setString(5, productoUsoVO.getQuienUsa());
            callStmt.setString(6, productoUsoVO.getIdPais());
            callStmt.setString(7, productoUsoVO.getIdciudadUso());
            callStmt.setDate(8, productoUsoVO.getFechaInicio());
            callStmt.setDate(9, productoUsoVO.getFechaFin());
            callStmt.setString(10, productoUsoVO.getEnProceso());
            callStmt.setString(11, productoUsoVO.getDuracion());
            callStmt.setString(12, productoUsoVO.getIngresosGenerados());
            callStmt.setString(13, productoUsoVO.getDetalleIngreso());
            callStmt.setString(14, productoUsoVO.getRecibeIngreso());
            callStmt.setString(15, productoUsoVO.getImportanciaITM());
            callStmt.setString(16, productoUsoVO.getIdProducto());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String matriculaProducto(ProductoVO productoVO, ProyectoInvestigacionVO proyectoInvestigacionVO)
            throws Exception {
        try {
            sql = "{call ITM_MATRICULAR_PRODUCTO(?,?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoVO.getNombreProducto());
            callStmt.setString(3, productoVO.getIdCategoria());
            callStmt.setString(4, productoVO.getIdClaseP());
            callStmt.setString(5, productoVO.getDescripcion());
            callStmt.setString(6, productoVO.getResultado());
            callStmt.setString(7, productoVO.getSectoresBenef());            
            callStmt.setString(8, productoVO.getIdTipoP());
            callStmt.setString(9, productoVO.getIdTipoPropiedadIntelectual());
            callStmt.setLong(10, proyectoInvestigacionVO.getIdProyecto());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String insertarCoopropietario(PropiedadIntelectualVO propiedadIntelectualVO, ProductoVO productoVO)
            throws Exception {
        try {
            sql = "{call ITM_INSERTAR_COOPROPIETARIO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, propiedadIntelectualVO.getIdPersona());
            callStmt.setString(3, productoVO.getIdProducto());
            callStmt.setString(4, propiedadIntelectualVO.getPorcentaje());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public List<AtributosVO> listarAtributos() throws Exception {
        List<AtributosVO> listaAtribu = new ArrayList<AtributosVO>();
        AtributosVO atributosVO;

        try {
            sql = "{call ITM_LISTA_ATRIBUTOS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                atributosVO = new AtributosVO();
                atributosVO.setNombreAtributo(res.getString(1));
                atributosVO.setIdTipoProducto(res.getString(2));
                atributosVO.setIdTipoAtributo(res.getString(3));
                atributosVO.setIdAtributoProducto(res.getString(4));
                atributosVO.setNombreTipoAtributo(res.getString(5));
                atributosVO.setNombreTipoProducto(res.getString(6));
                atributosVO.setEspecifico(res.getString(7));
                atributosVO.setLongitud(res.getString(8));
                atributosVO.setIndicadorVerificacion(res.getString(9));
                listaAtribu.add(atributosVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaAtribu;
    }

    public String modificarProducto(ProductoVO productoVO) throws Exception {
        try {
            sql = "{call ITM_MODIFICAR_PRODUCTO(?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoVO.getIdProducto());
            callStmt.setString(3, productoVO.getIdCategoria());
            callStmt.setString(4, productoVO.getIdClaseP());
            callStmt.setString(5, productoVO.getDescripcion());
            callStmt.setString(6, productoVO.getResultado());
            callStmt.setString(7, productoVO.getSectoresBenef());
            callStmt.setDate(8, productoVO.getFModificacion());
            callStmt.setString(9, productoVO.getIdTipoP());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String modificarEstadoProducto(ProductoVO productoVO) throws Exception {
        try {
            sql = "{call ITM_MODIFICAR_ESTADO_PRODUCTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoVO.getIdEstado());
            callStmt.setString(3, productoVO.getIdProducto());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String InsertarCriterioProducto(CriteObservaProduVO criteObservaProduVO) throws Exception {
        try {
            sql = "{call ITM_INSERTAR_CRITERIOS_PRODUCTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, criteObservaProduVO.getIdCriterio());
            callStmt.setString(3, criteObservaProduVO.getIdProduco());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String guardarArchivoProducto(ArchivoProductoVO archivoProductoVO) {
        String resultado = "";

        try {
            sql = "{call ITM_ADJUNTAR_ARCHIVO_PRODUCTO(?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, archivoProductoVO.getNombreArchivo());
            callStmt.setString(3, archivoProductoVO.getDescripcion());
            callStmt.setString(4, archivoProductoVO.getRutaArchivo());
            callStmt.setDate(5, archivoProductoVO.getFecha());
            callStmt.setString(6, archivoProductoVO.getIdProducto());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (Exception ce) {
            ce.printStackTrace();
        }

        return resultado;
    }

    public List<ProductoVO> consultarProductoProyecto(ProyectoInvestigacionVO proyectoInvestigacionVO,
            ProductoVO productoVO)
            throws Exception {
        List<ProductoVO> listaProduc = new ArrayList<ProductoVO>();

        try {
            sql = "{call ITM_CONSULTAR_PRODUCTO_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvestigacionVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                productoVO = new ProductoVO();
                productoVO.setIdProducto(res.getString(1));
                productoVO.setNombreProducto(res.getString(2));
                productoVO.setDescripcion(res.getString(3));
                productoVO.setResultado(res.getString(4));
                productoVO.setSectoresBenef(res.getString(5));
                productoVO.setFRegistro(res.getDate(6));
                productoVO.setFModificacion(res.getDate(7));
                productoVO.setNombreTipoProducto(res.getString(8));
                productoVO.setNombreCategoria(res.getString(9));
                productoVO.setNombreClase(res.getString(10));
                listaProduc.add(productoVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaProduc;
    }

    public List<ProductoVO> consultarProductoNombre(ProductoVO productoVO) throws ControlException, SQLException {
        List<ProductoVO> listaProduc = new ArrayList<ProductoVO>();

        try {
            sql = "{call ITM_CONSULTAR_PRODUCTO_NOMBRE(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getNombreProducto());
            res = callStmt.executeQuery();

            while (res.next()) {
                productoVO = new ProductoVO();
                productoVO.setIdProducto(res.getString(1));
                productoVO.setNombreProducto(res.getString(2));
                productoVO.setDescripcion(res.getString(3));
                productoVO.setResultado(res.getString(4));
                productoVO.setSectoresBenef(res.getString(5));
                productoVO.setFRegistro(res.getDate(6));
                productoVO.setFModificacion(res.getDate(7));
                productoVO.setNombreTipoProducto(res.getString(8));
                productoVO.setNombreCategoria(res.getString(9));
                productoVO.setNombreClase(res.getString(10));
                listaProduc.add(productoVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaProduc;
    }

    public ProductoVO consultarProductoEspecifico(ProductoVO productoVO) throws ControlException, SQLException {
        try {
            sql = "{call ITM_CONSULTAR_PRODUCTO_ID(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getIdProducto());
            res = callStmt.executeQuery();

            if (res.next()) {
                //productoVO.setIdProducto(res.getString(1));
                productoVO.setNombreProducto(res.getString(1));
                productoVO.setDescripcion(res.getString(2));
                productoVO.setResultado(res.getString(3));
                productoVO.setSectoresBenef(res.getString(4));
                productoVO.setFRegistro(res.getDate(5));
                productoVO.setFModificacion(res.getDate(6));
                productoVO.setIdCategoria(res.getString(7));
                productoVO.setNombreCategoria(res.getString(8));
                productoVO.setIdTipoP(res.getString(9));
                productoVO.setNombreTipoProducto(res.getString(10));
                productoVO.setIdClaseP(res.getString(11));
                productoVO.setNombreClase(res.getString(12));
                productoVO.setTituloProyecto(res.getString(13));
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return productoVO;
    }

    public List<ProductoUsoVO> ConsultaUsos(ProductoVO productoVO) throws Exception {
        List<ProductoUsoVO> listaUsos = new ArrayList<ProductoUsoVO>();
        ProductoUsoVO productoUsoVO;

        try {
            sql = "{call ITM_CONSULTAR_USO_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getIdProducto());
            res = callStmt.executeQuery();

            while (res.next()) {
                productoUsoVO = new ProductoUsoVO();
                productoUsoVO.setDescripcionUso(res.getString(1));
                listaUsos.add(productoUsoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaUsos;
    }

    public EstadoVO consultarEstadoProducto(ProductoVO productoVO) throws ControlException, SQLException {
        EstadoVO estadoVO = new EstadoVO();

        try {
            sql = "{call ITM_CONSULTAR_ESTADO_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getIdProducto());
            res = callStmt.executeQuery();

            if (res.next()) {

                // estadoVO = new EstadoVO();
                estadoVO.setNombreEstado(res.getString(1));
                estadoVO.setFechaRechazo(res.getDate(2));
                estadoVO.setMotivoRechazo(res.getString(3));
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return estadoVO;
    }

    public List<AtributosVO> ConsultaAtribuProducEspe(ProductoVO productoVO) throws Exception {
        List<AtributosVO> listaAtribu = new ArrayList<AtributosVO>();
        AtributosVO atributosVO;

        try {
            sql = "{call ITM_CONSULTAR_ATRIBUTO_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getIdProducto());
            res = callStmt.executeQuery();

            while (res.next()) {
                atributosVO = new AtributosVO();
                atributosVO.setNombreAtributo(res.getString(1));
                atributosVO.setValor(res.getString(2));
                listaAtribu.add(atributosVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaAtribu;
    }

    public List<ProductosEventoVO> ConsultaEventoAsociado(ProductoVO productoVO) throws Exception {
        List<ProductosEventoVO> listaEventoAsoci = new ArrayList<ProductosEventoVO>();
        ProductosEventoVO productosEventoVO;

        try {
            sql = "{call ITM_CONSULTAR_EVENTOS_DEL_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getIdProducto());
            res = callStmt.executeQuery();

            while (res.next()) {
                productosEventoVO = new ProductosEventoVO();
                productosEventoVO.setNombreEvento(res.getString(1));
                productosEventoVO.setEnProceso(res.getString(2));
                productosEventoVO.setCostoAsociado(res.getString(3));
                productosEventoVO.setResultadoObtenido(res.getString(4));
                listaEventoAsoci.add(productosEventoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaEventoAsoci;
    }

    public List<PropiedadIntelectualVO> ConsultaDueñoProduAsociado(ProductoVO productoVO) throws Exception {
        List<PropiedadIntelectualVO> listaDueñoAsoci = new ArrayList<PropiedadIntelectualVO>();
        PropiedadIntelectualVO propiedadIntelectualVO;

        try {
            sql = "{call ITM_CON_DUEÑO_PROPI_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, productoVO.getIdProducto());
            res = callStmt.executeQuery();

            while (res.next()) {
                propiedadIntelectualVO = new PropiedadIntelectualVO();
                propiedadIntelectualVO.setNombrePersona(res.getString(1));
                propiedadIntelectualVO.setTipopropiedad(res.getString(2));
                propiedadIntelectualVO.setPorcentaje(res.getString(3));
                listaDueñoAsoci.add(propiedadIntelectualVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaDueñoAsoci;
    }

    public List<ProductoVO> listaProducEntrgados() throws Exception {
        List<ProductoVO> listaEntregados = new ArrayList<ProductoVO>();
        ProductoVO productoVO;

        try {
            sql = "{call ITM_LISTAR_PRODUCTOS_ENTREGADOS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                productoVO = new ProductoVO();
                productoVO.setIdProducto(res.getString(1));
                productoVO.setNombreProducto(res.getString(2));
                listaEntregados.add(productoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaEntregados;
    }

    public List<EvaluacionProductoVO> ConsultaItem(EvaluacionProductoVO evaluacionProductoVO) throws Exception {
        List<EvaluacionProductoVO> listaItem = new ArrayList<EvaluacionProductoVO>();

        try {
            sql = "{call ITM_CONSULTAR_ITEM_EVALUACION_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, evaluacionProductoVO.getIdProducto());
            res = callStmt.executeQuery();

            while (res.next()) {
                evaluacionProductoVO = new EvaluacionProductoVO();
                evaluacionProductoVO.setNombreItem(res.getString(1));
                evaluacionProductoVO.setRequerido(res.getString(2));
                evaluacionProductoVO.setNombreCriterio(res.getString(3));
                evaluacionProductoVO.setIdItem(res.getString(4));
                listaItem.add(evaluacionProductoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaItem;
    }

    public String aprobarProducto(ProductoVO productoVO) throws Exception {
        try {
            sql = "{call ITM_INSERTAR_APROBADO_PRODUCTO(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, productoVO.getIdProducto());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String rechazarProducto(EstadoVO estadoVO) throws Exception {
        try {
            sql = "{call ITM_RECHAZAR_PRODUCTO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, estadoVO.getIdProducto());
            callStmt.setDate(3, estadoVO.getFechaRechazo());
            callStmt.setString(4, estadoVO.getMotivoRechazo());
            callStmt.execute();
            temp = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return temp;
    }

    public String insertarEvaluacion(EvaluacionProductoVO evaluacionProductoVO) throws DAOException {
        String mensaje = "";
        String error = "";
        try {
            sql = "{call PRC_ITM_REGISTRAR_EVALUACION_PRODUCTO(?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, evaluacionProductoVO.getIdCriterio());
            callStmt.setString(2, evaluacionProductoVO.getIdProducto());
            callStmt.setString(3, evaluacionProductoVO.getIdItem());
            callStmt.setLong(4, evaluacionProductoVO.getPeso());
            callStmt.setString(5, evaluacionProductoVO.getRequerido());
            callStmt.setLong(6, evaluacionProductoVO.getIdEtiqueta());
            callStmt.setString(7, evaluacionProductoVO.getCumple());
            callStmt.registerOutParameter(8, java.sql.Types.VARCHAR);
            callStmt.registerOutParameter(9, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(8);
            error = callStmt.getString(9);
            if(error != null){
                throw new DAOException(error);
            }
            return mensaje;
        } catch (SQLException ex) {
            ex.printStackTrace();
            Logger.getLogger(ProductosDAO.class.getName()).log(Level.SEVERE, error, ex);
            throw new DAOException(error, ex);
        }
    }

    public List<EvaluacionProductoVO> consultarCriterioProducto(EvaluacionProductoVO e) throws DAOException {
        List<EvaluacionProductoVO> lista = new ArrayList<EvaluacionProductoVO>();
        EvaluacionProductoVO evaluacionProductoVO;
        long anterior = 0;
        try {
            sql = "{call PRC_ITM_CONSULTAR_CRITERIO_PRODUCTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, Long.parseLong(e.getIdProducto()));
            res = callStmt.executeQuery();
            while (res.next()) {
                evaluacionProductoVO = new EvaluacionProductoVO();
                evaluacionProductoVO.setIdCriterio(res.getLong(3));
                evaluacionProductoVO.setNombreCriterio(res.getString(4));
                if (anterior != res.getLong(3)) {
                    lista.add(evaluacionProductoVO);
                    anterior = res.getLong(3);
                }
            }
            return lista;
        } catch (SQLException ex) {
            Logger.getLogger(ProductosDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Errror al consultar", ex);
        }

    }

    public List<ItemEvaluacionVO> consultarItemsEvaluacion(EvaluacionProductoVO e, long idCriterio) throws DAOException {
        List<ItemEvaluacionVO> lista = new ArrayList<ItemEvaluacionVO>();
        ItemEvaluacionVO itemsEvaluacionVO;
        try {
            sql = "{call PRC_ITM_CONSULTAR_ITEMS_EVALUACION(?, ?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, Long.parseLong(e.getIdProducto()));
            callStmt.setLong(2, idCriterio);
            res = callStmt.executeQuery();
            while (res.next()) {
                itemsEvaluacionVO = new ItemEvaluacionVO();
                itemsEvaluacionVO.setIdItem(res.getLong(2));
                itemsEvaluacionVO.setNombreItem(res.getString(4));
                itemsEvaluacionVO.setPeso(res.getLong(5));
                itemsEvaluacionVO.setRequerido(res.getString(6));
                lista.add(itemsEvaluacionVO);
            }
            return lista;
        } catch (SQLException ex) {
            Logger.getLogger(ProductosDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar", ex);
        }
    }

    public void registrarEvaluacionProducto(List<EvaluacionProductoVO> listaEvaluacion, long idEtiqueta) {
        try {
            sql = "";
            callStmt = dbConexion.prepareCall(sql);
            for (int i = 0; i < listaEvaluacion.size(); i++) {
                callStmt.setLong(1, idEtiqueta);
            }
        } catch (SQLException ex) {
            Logger.getLogger(ProductosDAO.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
}
